﻿<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
	<head>
		<meta charset="utf-8"/>
		<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
		<title>Функции. Понятие модуля</title>

		<link rel="stylesheet" type="text/css" href="http://moodle.spb.ru/file.php/84/python/standby.css"/><!-- page style: default -->
	</head>
	<body>
		<div class='page'>
			<h2>Функции. Понятие модуля</h2>
			<p>
				Мы уже говорили о том, что Python - язык мультипарадигменный. Это значит, что вы можете использовать приёмы ООП (создание объектов и их интерфейсов), возможности функционального программирования (обработка последовательностей, композиция функций, рекурсия и прочие), ну и, конечно, никто не запрещает в полной мере использовать возможности императивного программирования при разработке различных программ.
			</p>
			<div class="note">
				<p>
					Вообще, будет более правильно сказать, что разработка программы на Python подразумевает использование различных стилей и парадигм совместно, а для этого нужно видеть, где тот или иной стиль принесёт максимальную пользу
				</p>
			</div>
			<p>
				В этом уроке мы поговорим об императивной составляющей языка, а именно о <b>функциях</b>. В языках C и Pascal вы уже встречались с понятием функции - эта языковая конструкция позволяла использовать метод "<a href="http://ru.wikipedia.org/wiki/Разделяй_и_властвуй_(информатика)" title="Посмотреть в ВИКИ">разделяй и властвуй</a>" для того, чтобы упростить процесс разработки и отладки приложений, а также избежать лишних ошибок.
			</p>
			<p>
				Вместо одной большой программы мы создавали небольшие подпрограммы - функции, код которых был прост и понятен. Из этих подпрограмм можно было собрать большое приложение, которое выполняло поставленную задачу.
			</p>
			<p>
				Разбиение на функции (подпрограммы) давало ещё одно преимущество - их можно было использовать при составлении других программ. Таким образом появлялись библиотеки часто используемых функций - в известных вам языках обязательно должны были быть встроенные функции, такие как, например <cite>abs</cite>, <cite>rand</cite>, <cite>sin</cite>, <cite>cos</cite> и другие, не только из области математики.
			</p>
			<h3>Функции в языке <b>Python</b></h3>
			<p>
				В Python'е создание функции мало чем отличается от создания функций в языках C или Pascal - сначала пишется ключевое слово, которое говорит интерпретатору, что мы пишем функцию, далее пишется имя-идентификатор функции (правила для имен функций такие же как для обычных идентификаторов), после имени функции указываются принимаемые аргументы в круглых скобках. Все вместе это формирует заголовок функции. После заголовка ставится уже известный вам символ <cite>:</cite> (начало нового блока кода), и ниже пишется тело функции с <u>новым отступом</u>.
			</p>
			<p>
				<span class="important">Программист может определять собственные функции двумя способами *</span>: с помощью <span class="important">ключевого слова <b>def</b></span> или <span class="important">прямо в выражении, посредством <b>lambda</b></span>.
			</p>
			<div class="note">
				<p>
					В этом уроке будет рассмотрен только первый из двух способов, а именно объявление функции с помощью ключевого слова <cite>def</cite>. Второй способ объявления больше относится к области функционального программирования, и он будет рассмотрен позже.
				</p>
			</div>
			<p>
				Пример простейшей функции в Python'е:
				<code>
					<span style="color: #000000;">	
						<span style="color: #0000FF;">def</span> f():<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">pass</span><br/>
					</span>
				</code>
			</p>
			<p>
				<cite>def</cite> - это то самое ключевое слово (сокращено от "define", то есть "объявление", "объявляю"). <cite>f</cite> - это имя функции (идентификатор). Список аргументов, как видите, пуст, но это не означает, что скобки можно опустить. Они - часть объявления функции, а их отсутствие в описании функции - <u>синтаксическая ошибка</u>. И в теле функции содержится всего один оператор, оператор <cite>pass</cite>. Это функция ничего не делает, но ее уже можно задействовать далее в коде программы:
				<code>
					<span style="color: #000000;">	
						f()		<br/>	
					</span>
				</code>
			</p>			
			<p>
				Объявлять функции можно в <u>любом</u> блоке программы (прощай C, здравствуй Pascal) : внутри <cite>if-else</cite>, в циклах, в других функциях и так далее:
				<code>
					<span style="color: #000000;">	
						<span style="color: #0000FF;">def</span> f():<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">def</span> ff():<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">def</span> fff():<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">pass</span><br/>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;fff()<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;ff()<br/>
					</span>
				</code>
			</p>	
			<p>
				Для передачи значений в функцию необходимо в её заголовке в списке параметров указать, что функция принимает аргументы. В языке C это выглядело бы примерно так:
			</p><br/>
			<p>
				<cite>... somefunc(int a, int b, float f) ...</cite>
			</p><br/>
			<p>
				Python, как вы помните, является языком с <u>динамической типизацией</u>, поэтому типы значений указывать не нужно. Пример выше в Python'е будет выглядеть следующим образом:
				<code>
					<span style="color: #000000;">	
						... somefunc(a, b, f) ...
					</span>
				</code>
			</p>	
			<p>
				И, например, вся функция целиком:
				<code>
					<span style="color: #000000;">	
						<span style="color: #0000FF;">def</span> f(a, b, f):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(a, b, f)
					</span>
				</code>
			</p>
			<p>
				А вызов этой функции может выглядеть следующем образом:
				<code>
					<span style="color: #000000;">	
						f(1, 2, 3.0)<br/>
						<span class="comment"># Будет выведено 1 2 3.0</span>		
					</span>
				</code>
			</p>		
			<p>
				<span class="important">При вызове функции нужно обязательно соблюсти число аргументов</span>. Данная функция принимает три аргумента, поэтому передать нужно так же три значения:
				<code>
					<span style="color: #000000;">
						f(1, 2)<span class="error"> # Ошибка</span>
					</span>
				</code>	
			</p>
			<p>
				Но зато мы не ограничены в плане типов значений. У нас только одно условие - передать 3 значения. Они могут быть любыми: числа, None, списки, кортежи и так далее:
				<code>
					<span style="color: #000000;">
						f(<span style="color: #0000FF;">None</span>, <span style="color: #0000FF;">True</span>, [1, 2, 3, 4])<br/>
						f('string', (1+1j), {1: 1})
					</span>
				</code>
			</p>
			<p>
				В обоих случаях функция отработает правильно: выведет на экран переданные ей значения.
			</p><br/>
			<p>
				Но если наша функция не просто выводит на печать значения а производит какие-либо операции с данными, например, сложение, то могут возникнуть проблемы, если будет передано значение неправильного типа:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">def</span> f(a, b, f):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(a + b + f)<br/>
						<br/>
						f(1, 2, 3.0) <span class="comment"># Выведет 6.0</span><br/>
						f(1, 2, '3') <span class="error"># TypeError: нельзя сложить строку с целым числом</span>
					</span>
				</code>
			</p>
			<p>
				Поэтому нужно очень внимательно следить за типами передаваемых значений. А лучше всего их даже проверять. <span class="important">Проверить тип переменной можно с помощью встроенной функции <cite><b>type()</b></cite></span>, которая принимает одно значение и возвращает его тип:
				<code>
					<span style="color: #000000;">
						print(type(1))    <span class="comment"># Выведет <class 'int'></span><br/>
						print(type(2.0))  <span class="comment"># Выведет <class 'float'></span><br/>
					</span>
				</code>
			</p>
			<p>
				Но эти команды только выводят типы, чтобы сравнить типы нужно воспользоваться операциями сравнения <cite>is</cite>, <cite>is not</cite> или <cite>==</cite>, <cite>!=</cite>, где с одной стороны стоит вызов функции <cite>type</cite>, а с другой имя типа:
				<code>
					<span style="color: #000000;">
						type(1) <span style="color: #0000FF;">is</span> int   <span class="comment"># True</span><br/>
						type([]) == list <span class="comment"># True</span><br/>
						type(1.0) == int <span class="comment"># False</span>
					</span>
				</code>
			</p>
			<p>
				С учетом этого предыдущую функцию можно переписать так, чтобы она, например, работала только, если два первых аргумента целого типа, а третий - число с плавающей точкой:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">def</span> f(a, b, f):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">if</span> type(a) <span style="color: #0000FF;">is</span> type(b) <span style="color: #0000FF;">is</span> int <span style="color: #0000FF;">and</span> type(f) <span style="color: #0000FF;">is</span> float:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print(a + b + f)<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">else</span>:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print('Wrong type!')<br/>
						<br/>
						f(1, 2, 3)    <span class="comment"># Wrong type!</span><br/>
						f(1, 2, 3.0)  <span class="comment"># 6.0</span><br/>
						f([], (), {}) <span class="comment"># Wrong type!</span><br/>
					</span>
				</code>
			</p>	
			<p>
				Как вы заметили, сравнение записано как <cite>type(a) is type(b) is int and type(f) is float</cite>, а не как <cite>type(a) is int and type(b) is int and type(f) is float</cite>. Дело в том, что Python поддерживает так называемые цепочечные сравнения:
				<code>
					<span style="color: #000000;">	
						1 &lt; 2 &lt; 3 &lt; 7 > 6 > 5 == 5 != 2&nbsp;<span class="comment"># True</span><br/>
						3 &lt; 2 > 1&nbsp;<span class="comment"># False</span><br/>
					</span>
				</code>
			</p>	
			<p>
				Если вторую команду записать с логическими операторами, то она будет выглядеть так:
				<code>
					<span style="color: #000000;">	
						3 &lt; 2 <span style="color: #0000FF;">and</span> 2 > 1<br/>
					</span>
				</code>
			</p>
			<p>
				По аналогии можно записать и первую команду, но это будет гораздо длиннее.
			</p>
			<h3>Аргументы функции</h3>
			<p>
				С некоторыми особенностями по передаче аргументов в функции вы уже познакомились. На самом деле они несколько шире, чем в других языках программирования, и сейчас вы в этом убедитесь.
			</p>
			<p>
				Во-первых, в объявлении функции <span class="important">можно задавать значения аргументов по-умолчанию</span>. Это означает, что данный параметр можно в функцию и не передавать, тогда ему будет соответствовать значение, заданное в заголовке функции. Такое значение можно установить с помощью операции присваивания:
				<code>
					<span style="color: #000000;">	
						<span style="color: #0000FF;">def</span> func(a, b, c = 0.5):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(a, b, c)<br/>
					</span>
				</code>
			</p>
			<p>
				При объявлении <span class="important">важно соблюдать порядок указания аргументов</span>. Аргументы со значением по-умолчанию должны быть записаны после обыкновенных аргументов. Следующий пример выведет ошибку при выполнении:
				<code>
					<span style="color: #000000;">	
						<span style="color: #0000FF;">def</span> func(a = 5, b): 	<span class="error"># Ошибка!</span><br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(a + b)<br/>
					</span>
				</code>
			</p>
			<p>
				Таким образом у нас может появится несколько вариантов вызова одной функции, если не учитывать возможные комбинации типов данных:
				<code>
					<span style="color: #000000;">	
						<span style="color: #0000FF;">def</span> sum3(a, b, c = 0):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">if</span> type(a) <span style="color: #0000FF;">is</span> type(b) <span style="color: #0000FF;">is</span> type(c) <span style="color: #0000FF;">is</span> int:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print("sum %d + %d + %d = %d" % (a, b, c, a+b+c))<br/>
						<br/>
						sum3(2, 4, 3) 		<span class="comment"># sum 2 + 3 + 4 = 9</span><br/>
						sum3(4, 16) 		<span class="comment"># sum 4 + 16 + 0 = 20</span><br/>
						sum3(5, 2.5) 		<span class="comment"># Ничего выведено не будет</span><br/>
					</span>
				</code>
			</p>
			<p>
				Как видите, функцию <cite>sum3</cite> мы можем вызвать с тремя или двумя передаваемыми аргументами. Если хотя бы один аргумент не является целым числом, то данная функция ничего выводить не будет.
			</p><br/>
			<p>
				Именно за счет аргументов по-умолчанию можно изменить вывод функции <cite>print()</cite>. По-умолчанию она всегда печатает с переходом на новую строку в конце:
				<code>
					<span style="color: #000000;">	
						<span style="color: #0000FF;">for</span> i <span style="color: #0000FF;">in</span> [1, 2, 3]:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(i)<br/>
						<span class="comment">#1</span><br/>
						<span class="comment">#2</span><br/>
						<span class="comment">#3</span><br/>
					</span>
				</code>
			</p>
			<p>
				Функция <cite>print()</cite> принимает аргумент <cite>end</cite>(что добавить в конец печатаемой строки), который по-умолчанию равен <cite>'\n'</cite>. Если передать свое значение, то можно избавиться от переходов на новую строку:
				<code>
					<span style="color: #000000;">	
						<span style="color: #0000FF;">for</span> i <span style="color: #0000FF;">in</span> [1, 2, 3]:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(i, end=' ')<br/>
						print() <br/>
						<span class="comment"># 1 2 3</span><br/>
					</span>
				</code>
			</p>
			<p>
				<cite>print()</cite> стоит для того, чтобы потом уже интерпретатор выводил с новой строки. Иначе могло бы оказаться, что какие-либо значения вывелись бы на экран сразу же за <cite>1 2 3</cite>.
			</p>
			<div class="note" title="Выжная информация">
				<p>
					Значения по умолчанию вычисляются только один раз. Это может создать проблемы, когда значение - список, словарь или объект многих классов. Классический пример:
					<code>
						<span style="color: #000000;">	
							<span style="color: #0000FF;">def</span> Append(n, List = []):<br/>
							&nbsp;&nbsp;&nbsp;&nbsp;List.append(n)<br/>
							&nbsp;&nbsp;&nbsp;&nbsp;print(List)<br/>
							<br/>
							myList = []<br/>
							Append(1, myList)<br/>
							Append(2, myList)<br/>
							<span class="comment"># Будет выведено:</span><br/>
							<span class="comment"># [1]</span><br/>
							<span class="comment"># [1, 2]</span><br/>
							<span class="comment"># Печатается значение myList</span><br/>
						</span>
					</code>
				</p>
				<p>
					Но если не передавать список в функцию, то она задействует значение по умолчанию:
					<code>
						<span style="color: #000000;">	
							Append(1)<br/>
							Append(2)<br/>
							Append(3)<br/>
							<span class="comment"># Будет выведено:</span><br/>
							<span class="comment"># [1]</span><br/>
							<span class="comment"># [1, 2]</span><br/>
							<span class="comment"># [1, 2, 3]</span><br/>
						</span>
					</code>
				</p>
				<p>
					Это происходит из-за того, что используемое значение по умолчанию вычисляется только один раз. Потом оно сохраняется между вызовами функции.
				</p>
				<p>
					Чтобы это обойти, можно функцию написать, например, так:
					<code>
						<span style="color: #000000;">	
							<span style="color: #0000FF;">def</span> Append(n, List=None):<br/>
							&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">if</span> List <span style="color: #0000FF;">is</span> None:<br/>
							&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;List = []<br/>
							&nbsp;&nbsp;&nbsp;&nbsp;List.append(n)<br/>
							&nbsp;&nbsp;&nbsp;&nbsp;print(List)<br/>
							<br/>
							Append(1)<br/>
							Append(2)<br/>
							Append(3)<br/>
							<span class="comment"># Будет выведено:</span><br/>
							<span class="comment"># [1]</span><br/>
							<span class="comment"># [2]</span><br/>
							<span class="comment"># [3]	</span><br/>
						</span>
					</code>
				</p>		
			</div>
			<p>
				Помимо аргументов со значением по-умолчанию, функции в <span class="important">Python поддерживают произвольное число аргументов</span>. Это значит что в одну функцию, при определённых условиях, можно передать 1, 3, 5, 25 аргументов, причём для этого не нужно составлять огромное объявление функции для учёта всех вариантов вызова.
			</p>
			<p>
				Для того, чтобы указать интерпретатору, что данная функция может принимать произвольное количество значений, следует после последнего обычного аргумента или аргумента со значением по-умолчанию вставить идентификатор и символ <cite>*</cite> перед ним:
				<code>
					<span style="color: #000000;">	
						<span style="color: #0000FF;">def</span> func(a, b, c = 0, *args):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">pass</span><br/>
					</span>
				</code>
			</p>
			<p>
				В приведённом примере <cite>args</cite> - это кортеж (имя, естественно, можно выбирать любое), содержащий все дополнительные аргументы. <span class="important">Важно соблюдать порядок объявления аргументов</span>. Следующий пример демонстрирует работу с неопределённым количеством аргументов:
				<code>
					<span style="color: #000000;">	
						<span style="color: #0000FF;">def</span> len_max_min(*numbers):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print("length = ", len(numbers))<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print("max = ", max(numbers))<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print("min = ", min(numbers))<br/>
						<br/>
						<span class="comment"># Можно указать любое число аргументов:</span><br/>
						len_max_min(1, 2, -1, 5, 3, 2.5) <br/>
						<span class="comment"># length = 6</span><br/>
						<span class="comment"># max = 5</span><br/>
						<span class="comment"># min = -1</span><br/>
						<br/>
						<span class="comment"># А можно ничего не передавать:</span><br/>
						len_max_min()<br/>
						<span class="error"># Ошибка, нельзя найти минимальный/максимальный элемент</span>	<br/>	
					</span>
				</code>
			</p><br/>
			<p>
				<span class="important">Python поддерживает так называемые именованные аргументы</span>. Это означает, что каждый такой аргумент будет иметь имя(в отличие от просто произвольного числа аргументов, когда все значения помещаются в кортеж), то есть аргументы передаются в виде пар "ключ: значение" - словарь.
			</p>
			<p>
				Чтобы функция поддерживала именованные аргументы, <span class="important">в объявлении <b>после записи всех аргументов</b>, следует добавить имя-идентификатор и два символа <cite>*</cite> перед ним - <cite>**</cite></span>:
				<code>
					<span style="color: #000000;">	
						<span style="color: #0000FF;">def</span> func1(a, b, c = 0, *args, **names):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(a, b, c, args, names)<br/>
						<br/>
						<span style="color: #0000FF;">def</span> func2(a, b, c = 0, **names):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(a, b, c, names)<br/>
						<br/>
						<span style="color: #0000FF;">def</span> func3(a, **names):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(a, names)<br/>
						<br/>
						<span style="color: #0000FF;">def</span> func4(**names):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(names)<br/>
					</span>
				</code>
			</p>
			<p>
				Имя <cite>names</cite> (может быть и другой идентификатор) связано со словарём, который создаётся при вызове функции следующим образом:
				<code>
					<span style="color: #000000;">	
						func3(5, value = 20, name = "Value")<br/>
						<span class="comment"># Будет выведено 5 {'value': 20, 'name': 'Value'}</span><br/>
					</span>
				</code>
			</p>
			<p>
				Именованных аргументов тоже может быть произвольное количество.
			</p>
			<p>
				<span class="important">Не забывайте о порядке объявления аргументов</span>. В функции <cite>func1</cite> представлен полный набор различных типов аргументов и их правильный порядок записи.
			</p>
			<h3>Возвращение значения из функции</h3>
			<p>
				Как и множество других языков программирования, Python позволяет возвращать значения из функции.
			</p>
			<p>
				Для этого служит уже знакомая вам <span class="important">инструкция <b>return</b></span>. Когда интерпретатор встречает данную инструкцию, выполнение тела функции прерывается:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">def</span> func(a, b = 5):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(a)<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">return</span><br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(b) <span class="comment"># Значение не будет выведено</span><br/>
					</span>
				</code>
			</p>
			<p>
				Можно, но не обязательно, указывать возвращаемое значение после записи return:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">def</span> sum2(a = 0, b = 0):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">return</span> a + b<br/>
						<br/>
						print(sum2(4, 6)) <span class="comment"># 10</span><br/>
					</span>
				</code>
			</p>
			<p>
				Если внутри функции нет инструкции <cite>return</cite> с возвращаемым значением, а есть только простой <cite>return</cite> или его нет вовсе, функция вернёт значение None.
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">def</span> func():<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">return</span><br/>
						<br/>
						type(func()) <span class="comment"># &lt;class 'NoneType'></span><br/>
					</span>
				</code>
			</p>
			<p>
				Если вам когда-либо необходимо было вернуть два и более значения из функции, вы сталкивались с ограничениями языка в этом плане и приходилось создавать дополнительные структуры или классы, чтобы обойти эти ограничения. В Python'е же такой проблемы нет, благодаря встроенной поддержке последовательностей.
			</p>
			<p>
				После инструкции <cite>return</cite> можно через запятую перечислить все значения, которые нужно вернуть, и они будут "упакованы" в кортеж, который и будет возвращен:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">def</span> get2values():<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">return</span> "pi", 3.141592<br/>
						<br/>
						t = get2values()<br/>
						print(t) <span class="comment"># ('pi', 3.141592)</span><br/>
						<br/>
						name, value = get2values()<br/>
						print(name, value) <span class="comment"># pi 3.141592</span><br/>
					</span>
				</code>
			</p>
			<p>
				Или же можно явно возвращаемые значения поместить в кортеж или список:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">def</span> get2values():<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">return</span> ['pi', 3.141592]<br/>
						<br/>
						res = get2values()<br/>
						print(res) <span class="comment"># ['pi', 3.141592]</span><br/>
					</span>
				</code>
			</p>
			<h3>Понятие модуля в <b>Python</b></h3>
			<p>
				Различные константы, функции, классы и другие объекты, относящиеся к какой-либо одной области разумно объединить в один <b>модуль</b>. Например, математические функции и константы можно поместить в один модуль, функции для работы со строками - в другой.
			</p>
			<p>
				Модули и вообще модульный подход позволяют просто использовать уже готовые, ранее написанные классы и функции в различных программах. Достаточно подключить модуль - и вам уже доступно всё его содержимое.
			</p>
			<p>
				Python, наверное, не был бы таким популярным языком, если бы он не поставлялся вместе с очень большой библиотекой модулей на все случаи жизни. Тут вам и полноценный инструментарий для работы с числами, строками, XML, базами данных, регулярными выражениями, web, пользовательским интерфейсом (GUI) - и это далеко не полный список всего того, что вам доступно "из коробки". Добавьте к этому ещё те модули, которые можно загрузить отдельно из интернета. И хороший стиль программирования на Python'е - это прежде всего использование готового, уже написанного кода, а не "создание своих <a href="http://ru.wikipedia.org/wiki/Велосипед" title="Посмотреть в ВИКИ">велосипедов</a>".
			</p>
			<p>
				Помимо понятия модуля, в Python используется понятие <b>пакета</b>. В пакет обычно помещаются модули, предназначенные для решения какой-то одной проблемы. Хорошим примером такого пакета является пакет xml.
			</p>
			<h3>Подключение модуля к программе</h3>
			<p>
				Подключение модуля к программе на Python осуществляется с помощью <span class="important">оператора <b>import</b></span>. У него есть две формы: <cite>import</cite> и <cite>from-import</cite>:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">import</span> this <span class="comment"># Уже знакомая вам строчка. this - имя модуля</span><br/>
					</span>
				</code>
			</p>		
			<p>
				Модуль оформляется в виде отдельного файла с исходным кодом. Стандартные модули находятся в каталоге, где их может найти соответствующий интерпретатор языка. Чтобы узнать, где интерпретатор Python ищет модули, нужно подключить специальный модуль <cite>sys</cite> и посмотреть значение переменной <cite>path</cite> в этом модуле:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">import</span> sys<br/>
						<br/>
						print(sys.path)<span class="comment"> # Выведет список полных путей</span><br/>
					</span>
				</code>
			</p>			
			<p>
				Интерпретатор также проверяет текущий каталог программы на наличие подключаемых модулей.
			</p>
			<p>
				Другой способ импорта модуля - <cite>from-import</cite>. Такой способ нужно использовать тогда, когда из определённого модуля нам нужны только некоторые функции, классы, константы и другие объекты.
			</p>
			<p>
				Предыдущий пример можно было бы переписать следующим образом:	
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">from</span> sys <span style="color: #0000FF;">import</span> path<br/>
						<br/>
						print(path)<br/>
					</span>
				</code>
			</p>
			<p>
				Как видите, после ключевого слова <cite>from</cite>, следует имя модуля, из которого мы хотим получить некоторые функции, константы и так далее. После слова <cite>import</cite> через запятую указываются нужные вам часть модуля. Можно использовать символ <cite>*</cite> для импортирования всех объектов (но это настоятельно не рекомендуется, чтобы не произошло конфликтов в пространстве имен).
			</p>
			<p>
				Обратите внимание на то, что во втором примере значение <cite>path</cite> узнаётся уже без указания имени основного модуля <cite>sys</cite>.
			</p>
			<p>
				При импорте модуля или его частей можно их переименовывать (если имя слишком неудобное или уже используется). Для этого предназначена <span class="important">инструкция <b>as</b></span>, после которой пишется новый идентификатор:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">import</span> sys <span style="color: #0000FF;">as</span> system<br/>
						<span class="comment"># argv - список аргументов командной строки</span><br/>
						<span style="color: #0000FF;">from</span> sys <span style="color: #0000FF;">import</span> argv <span style="color: #0000FF;">as</span> cmd <br/>
						<br/>
						print(system.path)<br/>
						print(cmd)<br/>
					</span>
				</code>
			</p>
			<p>
				Если Ваша программа состоит из нескольких .py файлов, то их можно точно также подключать друг в друге. Например, есть модуль <cite>mainModule</cite> и модуль <cite>funcModule</cite> и они лежат в одной папке. То есть в одной папке у вас должно быть два файла с расширением .py, имеющие такие-же имена. Тогда, чтобы импортировать <cite>funcModule</cite> в <cite>mainModule</cite>, нужно всего лишь написать:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">import</span> funcModule<br/>
					</span>
				</code>
			</p>
			<p>
				Или если нужна только какая-нибудь функция (допустим, <cite>multiply()</cite>):
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">from</span> funcModule <span style="color: #0000FF;">import</span> multiply<br/>
					</span>
				</code>
			</p>
			<p>
				Не забывайте, что Python - язык регистрозависимый, то есть команда <cite>import funcmodule</cite> вызовет ошибку, ведь модуля <cite>funcmodule</cite> нет, а есть <cite>funcModule</cite>.
			</p>
			<div class="note">
				<p>
					Инструкцию <cite>import</cite> или <cite>from-import</cite> можно использовать в любом блоке кода программы, жестких ограничений нет. Но, тем не менее, это лучше всего делать в самом начале модуля.
				</p>
			</div>
			<hr/>
			<p>
				В следующем уроке мы узнаем о возможностях Python в области объектно-ориентированного программирования, которое существенно отличается от его реализации в языке C++ или Java.
			</p>
		</div>
		<div class="footer"></div>
	</body>
</html>